import { message } from 'antd';

// DeepSeek API 配置
const DEEPSEEK_API_BASE = process.env.NODE_ENV === 'development'
    ? 'http://localhost:16066'
    : window.location.origin;

interface DeepSeekChatRequest {
    content: string;
    model?: string;
    max_tokens?: number;
    temperature?: number;
    stream?: boolean;
}

interface DeepSeekChatResponse {
    success: boolean;
    data: {
        content: string;
        timestamp: string;
    };
}

class DeepSeekApiService {
    private baseUrl: string;

    constructor() {
        this.baseUrl = `${DEEPSEEK_API_BASE}/api/deepseek`;
    }

    /**
     * 检查DeepSeek服务状态
     */
    async checkStatus(): Promise<boolean> {
        try {
            const response = await fetch(`${this.baseUrl}/status`, {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                },
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const data = await response.json();
            return data.status === 'ok';
        } catch (error) {
            console.error('检查DeepSeek服务状态失败:', error);
            return false;
        }
    }

    /**
     * 调用DeepSeek Chat API获取推荐
     */
    async getWineRecommendation(prompt: string): Promise<string> {
        try {
            // 先检查服务状态
            const isServiceAvailable = await this.checkStatus();
            if (!isServiceAvailable) {
                throw new Error('DeepSeek服务当前不可用，请稍后再试');
            }

            // 构建完整的提示词，包含系统角色和用户输入
            const fullPrompt = `你是一位专业的精酿啤酒品鉴师和推荐专家。请根据用户的喜好选择，为他们推荐最适合的精酿啤酒。回答要详细、专业且实用，包括具体的酒款名称、风味特点、推荐理由等。请用中文回答。

用户需求：
${prompt}

请提供专业的精酿啤酒推荐建议。`;

            const requestBody: DeepSeekChatRequest = {
                content: fullPrompt,
                model: 'deepseek-chat',
                max_tokens: 2000,
                temperature: 0.7,
                stream: false
            };

            const response = await fetch(`${this.baseUrl}/chat`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Accept': 'application/json',
                },
                body: JSON.stringify(requestBody),
            });

            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`API请求失败: ${response.status} - ${errorText}`);
            }

            const data: DeepSeekChatResponse = await response.json();

            console.log('data', data)
            if (!data.success || !data.data || !data.data.content) {
                throw new Error('API返回数据格式错误');
            }

            const recommendation = data.data.content;

            if (!recommendation || recommendation.trim() === '') {
                throw new Error('获取到空的推荐内容');
            }

            return recommendation.trim();
        } catch (error) {
            console.error('调用DeepSeek API失败:', error);

            // 根据错误类型显示不同的提示信息
            if (error instanceof Error) {
                if (error.message.includes('fetch')) {
                    message.error('网络连接失败，请检查网络连接');
                    throw new Error('网络连接失败，请检查网络连接');
                } else if (error.message.includes('服务不可用')) {
                    message.error(error.message);
                    throw error;
                } else {
                    message.error('获取推荐失败，请重试');
                    throw new Error('获取推荐失败，请重试');
                }
            } else {
                message.error('未知错误，请重试');
                throw new Error('未知错误，请重试');
            }
        }
    }

    /**
     * 构建推荐提示词
     */
    buildRecommendationPrompt(selections: {
        malt: string[];
        hops: string[];
        yeast: string[];
        mouthfeel: string;
        alcohol: string;
    }): string {
        const { malt, hops, yeast, mouthfeel, alcohol } = selections;

        // 检查是否有选择
        if (malt.length === 0 && hops.length === 0 && yeast.length === 0 && !mouthfeel && !alcohol) {
            return '请为我推荐一些优质的精酿啤酒，包括不同风格和特色的酒款。';
        }

        let prompt = '根据我的喜好，请为我推荐合适的精酿啤酒：\n\n';

        if (malt.length > 0) {
            prompt += `🌾 麦芽风味偏好：${malt.join('、')}\n`;
        }

        if (hops.length > 0) {
            prompt += `🌿 啤酒花风味偏好：${hops.join('、')}\n`;
        }

        if (yeast.length > 0) {
            prompt += `🍺 酵母风味偏好：${yeast.join('、')}\n`;
        }

        if (mouthfeel) {
            prompt += `👅 口感偏好：${mouthfeel}\n`;
        }

        if (alcohol) {
            prompt += `🔥 酒精度偏好：${alcohol}\n`;
        }

        prompt += '\n请根据以上喜好，推荐3-5款最适合的精酿啤酒，包括：\n';
        prompt += '1. 具体的酒款名称和酒厂\n';
        prompt += '2. 详细的风味描述\n';
        prompt += '3. 为什么适合我的选择偏好\n';
        prompt += '4. 建议的品鉴温度和搭配食物\n';
        prompt += '5. 购买建议或替代选择\n\n';
        prompt += '请提供专业且实用的建议，帮助我找到最喜欢的精酿啤酒。';

        return prompt;
    }

    /**
     * 流式获取推荐（改进版实现）
     */
    async getWineRecommendationStream(
        prompt: string,
        onChunk?: (chunk: string) => void
    ): Promise<string> {
        try {
            // 先检查服务状态
            const isServiceAvailable = await this.checkStatus();
            if (!isServiceAvailable) {
                throw new Error('DeepSeek服务当前不可用，请稍后再试');
            }

            // 构建完整的提示词
            const fullPrompt = `你是一位专业的精酿啤酒品鉴师和推荐专家。请根据用户的喜好选择，为他们推荐最适合的精酿啤酒。回答要详细、专业且实用，包括具体的酒款名称、风味特点、推荐理由等。请用中文回答。

用户需求：
${prompt}

请提供专业的精酿啤酒推荐建议。`;

            const requestBody = {
                content: fullPrompt,
                model: 'deepseek-chat',
                max_tokens: 2000,
                temperature: 0.7,
                stream: true
            };

            console.log('发送流式请求到:', `${this.baseUrl}/chat/stream`);
            console.log('请求体:', requestBody);

            const eventSource = new EventSource(`${this.baseUrl}/chat/stream?content=${(fullPrompt)}`);

            eventSource.onmessage = (event: MessageEvent) => {
                const data = JSON.parse(event.data);
                console.log('接收到数据:', data);
            }

            eventSource.onerror = (event: Event) => {
                console.error('流式请求失败:', event);
                eventSource.close();
            }

            // const response = await fetch(`${this.baseUrl}/chat/stream`, {
            //     method: 'POST',
            //     headers: {
            //         'Content-Type': 'application/json',
            //         'Accept': 'text/event-stream',
            //         'Cache-Control': 'no-cache',
            //     },
            //     body: JSON.stringify(requestBody),
            // });

            // console.log('响应状态:', response.status, response.statusText);
            // console.log('响应头:', response.headers);

            // if (!response.ok) {
            //     const errorText = await response.text();
            //     console.error('请求失败:', errorText);
            //     throw new Error(`API请求失败: ${response.status} - ${errorText}`);
            // }

            // if (!response.body) {
            //     throw new Error('响应体为空');
            // }

            // const reader = response.body.getReader();
            // const decoder = new TextDecoder();
            // let fullContent = '';
            // let buffer = '';

            // try {
            //     while (true) {
            //         const { done, value } = await reader.read();
            //         if (done) {
            //             console.log('流读取完成');
            //             break;
            //         }

            //         // 解码并添加到缓冲区
            //         const chunk = decoder.decode(value, { stream: true });
            //         buffer += chunk;
            //         console.log('接收到原始数据块:', chunk);

            //         // 按行处理
            //         const lines = buffer.split('\n');
            //         buffer = lines.pop() || ''; // 保留不完整的行

            //         for (const line of lines) {
            //             const trimmedLine = line.trim();
            //             if (!trimmedLine) continue;

            //             console.log('处理行:', trimmedLine);

            //             if (trimmedLine.startsWith('data: ')) {
            //                 const jsonStr = trimmedLine.slice(6).trim();

            //                 if (jsonStr === '[DONE]') {
            //                     console.log('收到结束信号');
            //                     return fullContent.trim() || '暂无推荐内容';
            //                 }

            //                 try {
            //                     const data = JSON.parse(jsonStr);
            //                     console.log('解析的数据:', data);

            //                     if (data.type === 'content' && data.content) {
            //                         fullContent += data.content;
            //                         console.log('累积内容长度:', fullContent.length);

            //                         if (onChunk) {
            //                             onChunk(data.content);
            //                         }
            //                     } else if (data.type === 'connected') {
            //                         console.log('连接建立:', data.message);
            //                     } else if (data.type === 'error') {
            //                         throw new Error(data.message);
            //                     } else if (data.type === 'done') {
            //                         console.log('响应完成:', data.message);
            //                         return fullContent.trim() || '暂无推荐内容';
            //                     }
            //                 } catch (parseError) {
            //                     console.warn('JSON解析失败:', parseError, '原始数据:', jsonStr);
            //                 }
            //             }
            //         }
            //     }

            //     return fullContent.trim() || '暂无推荐内容';
            // } finally {
            //     reader.releaseLock();
            // }
        } catch (error) {
            console.error('流式调用失败:', error);

            // 如果流式失败，回退到普通调用
            console.log('回退到普通API调用');
            try {
                return await this.getWineRecommendation(prompt);
            } catch (fallbackError) {
                console.error('普通调用也失败:', fallbackError);
                throw error; // 抛出原始错误
            }
        }
    }
}

// 导出单例实例
export const deepseekApiService = new DeepSeekApiService();
export default deepseekApiService; 